home *** CD-ROM | disk | FTP | other *** search
/ Deutsche Edition 1 / Deutsche Edition 1.iso / amok / amok_lha / amok59.lha / AmokEd_V1.02b / txt / EdFileTools.mod < prev    next >
Text File  |  1993-08-15  |  19KB  |  678 lines
  1. (*************************************************************************
  2.  
  3. :Program.    EdFileTools.mod
  4. :Contents.   File-Management for AmokEd
  5. :Author.     Hartmut Goebel
  6. :Language.   Oberon
  7. :Translator. Amiga Oberon Compiler V2.00
  8. :Imports.    Printf (Volker Rudolph)
  9. :History.    V0.1, 25 Sep 1990 Hartmut Goebel
  10. :History.    V1.0, 14 Apr 1991 Hartmut Goebel [hG]
  11. :History.    V1.0b 22 Apr 1991 [hG] Source-Bug in LoadLines removed
  12. :History.    V1.1  22 Apr 1991 [hG] +doSaveConfig, GetConfig
  13. :History.    V1.2  11 Jun 1991 [hg], Volker Rudolph: +_Fast_LoadLines etc.
  14. :History.    V1.2b 21 Oct 1991 [hg] - Bug in ArpLoad (File/path-Split)
  15. :Date.       21 Oct 1991 12:26:24
  16.  
  17. *************************************************************************)
  18.  
  19. MODULE EdFileTools;
  20.  
  21. IMPORT
  22.   ASCII, Printf,
  23.   EdGadgets,
  24.   asl: ASL,
  25.   d  : Dos,
  26.   e  : Exec,
  27.   edB: EdBlocks,
  28.   edD: EdDisplay,
  29.   edE: EdErrors,
  30.   edG: EdGlobalVars,
  31.   edK: EdKeyboard,
  32.   edL: EdLowLevel,
  33.   fs : EdFileSystem,
  34.   g  : Graphics,
  35.   I  : Intuition,
  36.   lst: EdLists,
  37.   ol : OberonLib,
  38.   str: Strings,
  39.   sys: SYSTEM,
  40.   u  : Utility;
  41.  
  42. (*------------------------------------------------------------------------*)
  43. (* $Debug- *)
  44. CONST
  45.   newFile*=0; (* NewFile oder InsFile  } müssen unterschiedlich  *)
  46.   saveAs*=1;  (* SaveAs oder SaveOld   } sein wegen ArpLoad/Save *)
  47.   saveBlock* = 2;
  48.   sourceDoNotTitle* = 3;
  49.   saveSysMap* = 0;
  50.  
  51.   NewFile*="NEWFILE";
  52.   InsFile*="INSFILE";
  53.   SaveAs*="SAVEAS";
  54.   SaveOld*="SAVEOLD";
  55.   SaveBlock*="SAVEBLOCK";
  56.  
  57.   Loading = "Loading...";
  58.   Saving = "Saving...";
  59.   FileNotFound = "File Not Found";
  60.   UnableToOpenFile = "Unable to open file";
  61.   ReadError = "Read Error!!";
  62.   WriteFailed = "Write failed!";
  63.   FileReqNotAvailable ="File Requester not available";
  64.   UnableToCD = "Unable to CD";
  65.   ConfigFileName = "s:AmokEd.config";
  66.  
  67.   ReqBody = I.IntuiText(0,1,g.jam2,12,8,NIL,
  68.     sys.ADR("Delete modified Image?"),NIL);
  69.   ReqOkay = I.IntuiText(0,1,g.jam2,6,3,NIL,sys.ADR(edG.Okay),NIL);
  70.   ReqCancel = I.IntuiText(0,1,g.jam2,6,3,NIL,sys.ADR(edG.Cancel),NIL);
  71.  
  72. VAR
  73.   arpbase: e.LibraryPtr;
  74. CONST
  75.   longDSize = 255;
  76.   longFSize = 126;
  77.   longPath = 0;
  78.  
  79. TYPE
  80.   DirName = ARRAY longDSize+1 OF CHAR;
  81.   FileName = ARRAY longFSize+1 OF CHAR;
  82.  
  83.   DirNamePtr = POINTER TO DirName;
  84.   FileNamePtr = POINTER TO FileName;
  85.  
  86. VAR
  87.   Dirname: DirName; (* wird auch als Buffer für SaveLines benutzt *)
  88.   Filename: FileName;
  89.  
  90. TYPE
  91.   FileRequester = STRUCT
  92.     hail      : e.ADDRESS;    (* Hailing text                 *)
  93.     file      : FileNamePtr;  (* Filename array (FCHARS + 1)  *)
  94.     dir       : DirNamePtr;   (* Directory array (DSIZE + 1)  *)
  95.     window    : I.WindowPtr;  (* Window requesting or NULL    *)
  96.     funcFlags : SHORTSET;     (* Set bitdef's below           *)
  97.     flags2    : SHORTSET;     (* New flags...                 *)
  98.     function  : PROCEDURE;    (* Your function, see bitdef's  *)
  99.     leftEdge  : INTEGER;      (* To be used later...          *)
  100.     topEdge   : INTEGER;
  101.     reserved  : ARRAY 3 OF INTEGER;
  102.     argList   : LONGINT;
  103.     userData  : e.ADDRESS;
  104.   END;
  105.  
  106.   FileRequesterPtr = POINTER TO FileRequester;
  107.  
  108. (*------------------------------------------------------------------------*)
  109.  
  110. PROCEDURE FileRequest {arpbase,-294}(fr{8}:FileRequesterPtr): BOOLEAN;
  111.  
  112. (*------------------------------------------------------------------------*)
  113.  
  114. PROCEDURE FileReq*(hail: edG.StringPtr): BOOLEAN;
  115. TYPE
  116.   NineTags = ARRAY 9 OF u.TagItem;
  117. VAR
  118.   i,j: INTEGER;
  119.   FR: FileRequester;
  120.   fr: asl.FileRequesterPtr;
  121.   tags: NineTags;
  122.   res: BOOLEAN;
  123. BEGIN
  124.   LOOP
  125.     j := str.Length(Filename);
  126.     WHILE (j>=0) AND (Filename[j]#":") AND (Filename[j]#"/") DO DEC(j) END;
  127.     IF j >= 0 THEN
  128.       str.Cut(Filename,0,j,Dirname);
  129.       str.Delete(Filename,0,i);
  130.     END;
  131.     IF asl.asl#NIL THEN
  132.       tags := NineTags(asl.hail,NIL,asl.window,NIL,
  133.         asl.file,NIL,asl.dir,NIL,asl.leftEdge,20,asl.topEdge,20,
  134.         asl.width,300,asl.height,200,u.done,NIL);
  135.       tags[0].data := hail;
  136.       tags[1].data := edG.Text.window;
  137.       tags[2].data := sys.ADR(Filename);
  138.       tags[3].data := sys.ADR(Dirname);
  139.       fr := asl.AllocAslRequest(asl.fileRequest,tags);
  140.       IF fr=NIL THEN EXIT END;
  141.       res := asl.RequestFile(fr);
  142.       COPY(fr.dir^,Dirname);
  143.       COPY(fr.file^,Filename);
  144.       asl.FreeFileRequest(fr);
  145.       IF NOT res THEN EXIT END;
  146.     ELSE
  147.       FR.hail     := hail;
  148.       FR.file     := sys.ADR(Filename);
  149.       FR.dir      := sys.ADR(Dirname);
  150.       FR.window   := edG.Text.window;;
  151.       FR.funcFlags:= SHORTSET{};
  152.       FR.flags2   := SHORTSET{longPath};
  153.       FR.function := NIL;
  154.       FR.leftEdge := 0;
  155.       FR.topEdge  := 0;
  156.       IF NOT FileRequest(sys.ADR(FR)) THEN EXIT END;
  157.     END;
  158.     j := str.Length(Dirname);
  159.     IF (j>0) AND (Dirname[j-1]#"/") AND (Dirname[j-1]#":") THEN
  160.       Dirname[j] := "/"; INC(j);
  161.       Dirname[j] := 0X;
  162.     END;
  163.     IF sys.SIZE(Filename)>j+str.Length(Filename) THEN
  164.       str.Insert(Filename,0,Dirname);
  165.       RETURN TRUE;
  166.     END;
  167.   END;
  168.   RETURN FALSE;
  169. END FileReq;
  170.  
  171.  
  172. PROCEDURE GetPathAndName(string: ARRAY OF CHAR;  (* $CopyArrays- *)
  173.                          VAR path, name: ARRAY OF CHAR);
  174. (* <string> kann die gleiche Var sein wie <path> *)
  175.  
  176. VAR
  177.   i: INTEGER;
  178. BEGIN
  179.   i := str.Length(string);
  180.   WHILE (i > 0) AND (string[i]#"/") AND (string[i]#":") DO
  181.     DEC(i);
  182.   END;
  183.   str.Cut(string,i+1,LEN(name),name);
  184.   str.Cut(string,0,i,name);
  185. END GetPathAndName;
  186.  
  187. (*-----------------------------------------------------------------------*)
  188. (*
  189. (* Lädt File <Name> in <List>, <Num> ist Anzahl geladener Zeilen *)
  190.  
  191. PROCEDURE LoadLines*(VAR List: lst.List; Source: BOOLEAN;
  192.                      (* $CopyArrays- *)
  193.                      Name: ARRAY OF CHAR): LONGINT;
  194. VAR
  195.   len: INTEGER;
  196.   newLine: edG.LinePtr;
  197.   Buffer: edG.StringPtr;
  198.   Num: LONGINT;
  199.   File: fs.File;
  200. BEGIN
  201.   ol.New(Buffer,sys.SIZE(edG.String));
  202.   IF Buffer=NIL THEN
  203.     INCL(edG.Status,edG.memoryFail); edG.Rc := edE.cmdSevere;
  204.     RETURN -1;
  205.   END;
  206.   Buffer^ := "";
  207.   IF NOT fs.Open(File,Name,FALSE) THEN
  208.     DISPOSE(Buffer); RETURN -1; END;
  209.   Num := 0;
  210.   LOOP
  211.     IF NOT fs.ReadString(File,Buffer^) THEN
  212.       IF File.status # fs.eof THEN
  213.         edG.Rc := edE.cmdSevere; edL.Title(ReadError);
  214.         Num := -1;
  215.       END;
  216.       EXIT;
  217.     END;
  218.     IF Source THEN
  219.       IF Buffer^ # "" THEN
  220.         Num := 0;
  221.         REPEAT
  222.           IF Buffer[Num]=ASCII.ht THEN Buffer[Num] := 20X; END;
  223.           INC(Num);
  224.         UNTIL (Num = edG.MaxLineLength) OR (Buffer[Num] = 0X);
  225.         edG.ExecCmd(Buffer);
  226.       END;
  227.     ELSE
  228.       len := str.Length(Buffer^);
  229.       REPEAT
  230.         DEC(len);
  231.       UNTIL (len < 0) OR (Buffer[len]#20X);
  232.       INC(len);
  233.       Buffer[len] := 0X;
  234.       len := len+edG.MemStepSize-(len MOD edG.MemStepSize);
  235.       edL.NewLine(newLine,len);
  236.       IF newLine#NIL THEN
  237.         e.CopyMem(Buffer^,newLine(edG.Line).string^,len);
  238.         lst.AddTail(List,newLine);
  239.         INC(Num);
  240.       ELSE
  241.         INCL(edG.Status,edG.memoryFail); edG.Rc := edE.cmdSevere;
  242.         Num := -1;
  243.       END; (* IF newLine # NIL *)
  244.     END;
  245.     IF Num < 0 THEN (* MemoryFailed *)
  246.       EXIT; END;
  247.   END; (* LOOP *)
  248.   IF fs.Close(File) THEN END;
  249.   DISPOSE(Buffer);
  250.   RETURN Num;
  251. END LoadLines;
  252. *)
  253.  
  254. (* NEW NEW NEW NEW NEW NEW NEW NEW NEW NEW NEW NEW NEW NEW NEW NEW *)
  255.  
  256. (* $CopyArrays- *)
  257. PROCEDURE FastLoadLines(VAR list:lst.List;name:ARRAY OF CHAR):LONGINT;
  258. CONST
  259.   BlockSize = 10000;
  260.   MaxLineSize = edG.LineAllocSize + edG.MaxLineLength;
  261.   ChunkSize = sys.SIZE(e.MemChunk);
  262.  
  263. VAR
  264.   line:POINTER TO edG.Line;
  265.   node:lst.NodePtr;
  266.   end:e.ADDRESS;
  267.   file:fs.File;
  268.   len:LONGINT;
  269.   num:LONGINT;
  270.  
  271. BEGIN
  272.   IF NOT fs.Open(file,name,FALSE) THEN
  273.     RETURN -1
  274.   END; (* IF *)
  275.  
  276.   lst.Init(list);
  277.   line := NIL;
  278.   num := 0;
  279.  
  280.   REPEAT
  281.  
  282.     (* do we need more memory ? *)
  283.     IF (line = NIL) OR
  284.        (sys.VAL(LONGINT,line) > (end - MaxLineSize)) THEN
  285.  
  286.       (* free unused memory of last block *)
  287.       IF line # NIL THEN
  288.         e.FreeMem(line,sys.VAL(LONGINT,end)-sys.VAL(LONGINT,line));
  289.       END; (* IF *)
  290.  
  291.       (* get new memory block *)
  292.       line := e.AllocMem(BlockSize,LONGSET{});
  293.       IF line = NIL THEN
  294.  
  295.         (* free memory used so far *)
  296.         node := lst.RemHead(list);
  297.         WHILE node # NIL DO
  298.           WITH node:edG.Line DO
  299.             e.FreeMem(node.string,node.len+edG.LineAllocSize);
  300.           END;
  301.           node := lst.RemHead(list);
  302.         END; (* WHILE *)
  303.  
  304.         IF fs.Close(file) THEN END;
  305.         INCL(edG.Status,edG.memoryFail);
  306.         edG.Rc := edE.cmdSevere;
  307.         RETURN -1;
  308.       END;
  309.  
  310.       end := line; INC(end,BlockSize);
  311.  
  312.     END; (* IF *)
  313.  
  314.     (* read line *) (* $TypeChk- *)
  315.     sys.INIT(line); (* $TypeChk= *)
  316.     line.string := sys.VAL(LONGINT,line) + edG.LineAllocSize;
  317.     len := fs.ReadStringLenTab(file,line.string^,8);
  318.     IF len >= 0 THEN
  319.       line.string[len] := "\o";
  320.       line.len := SHORT(len + ChunkSize-(len MOD ChunkSize));
  321.       lst.AddTail(list,line);
  322.       INC(line,line.len + edG.LineAllocSize);
  323.       INC(num);
  324.     END; (* IF *)
  325.  
  326.   UNTIL (len = -1);
  327.  
  328.   IF sys.VAL(LONGINT,line) < end THEN
  329.     e.FreeMem(line,sys.VAL(LONGINT,end)-sys.VAL(LONGINT,line));
  330.   END; (* IF *)
  331.  
  332.   IF fs.Close(file) THEN END;
  333.   RETURN num;
  334. END FastLoadLines;
  335.  
  336.  
  337. PROCEDURE doLoad*;
  338. VAR
  339.   oldlock: d.FileLockPtr;
  340.   NumNewLines: LONGINT;
  341.   TempLine: edG.LinePtr;
  342.   NewList: lst.List;
  343. BEGIN
  344.   edD.PutBackLine;
  345.   IF (newFile IN edG.ArgSet) THEN
  346.     IF (edG.modified IN edG.Text.status)
  347.     AND NOT I.AutoRequest(edG.Text.window,ReqBody,sys.ADR(ReqOkay),ReqCancel,
  348.                           LONGSET{},LONGSET{},320,58)
  349.     THEN
  350.       edG.Rc := edE.cmdValid1; RETURN;
  351.     END;
  352.     e.CopyMemQuick(edG.Arg[0]^,edG.Text.name,edG.FileNameLength);
  353.     edG.Text.name[edG.FileNameLength-1] := 0X;
  354.     edB.doUnblock;
  355.   END;
  356.  
  357.   oldlock := d.CurrentDir(edG.Text.dirLock);
  358.   edL.Title(Loading); edG.Rc := edE.cmdValid2;
  359.   NumNewLines := FastLoadLines(NewList,edG.Arg[0]^);
  360.   IF NumNewLines = -1 THEN
  361.     IF edG.Rc < edE.FailLevel THEN
  362.       edG.Rc := edE.cmdError; edL.Title(FileNotFound);
  363.     END;
  364.     RETURN;
  365.   END;
  366.   edL.Title(edG.Okay);
  367.   oldlock := d.CurrentDir(oldlock);
  368.  
  369.   (* Newfile oder leeres File *)
  370.   IF (newFile IN edG.ArgSet) OR (edG.Text.actLinePtr(edG.Line).string^ = "")
  371.                        AND (edG.Text.numberOfLines=1) THEN
  372.     edL.FreeLines(edG.Text.lineList,edG.Text.lineList.head(edG.Line),
  373.                   edG.Text.lineList.tail(edG.Line));
  374.   END;
  375.   IF edG.Text.lineList.head=NIL THEN
  376.     edG.Text.line := 0; edG.Text.pos := 0; edG.Text.topLine := 0;
  377.     EXCL(edG.Text.status,edG.modified);
  378.     IF NewList.head#NIL THEN
  379.       edG.Text.numberOfLines := NumNewLines;
  380.       lst.AddMarkHead(edG.Text.lineList,NewList);
  381.     ELSE
  382.       edG.Text.numberOfLines := 1;
  383.       edL.NewLine(TempLine,edG.ChunkSize);
  384.       lst.AddHead(edG.Text.lineList,TempLine);
  385.     END;
  386.     edG.Text.actLinePtr := edG.Text.lineList.head(edG.Line);
  387.     edG.Text.topLinePtr := edG.Text.actLinePtr;
  388.   ELSE
  389.     INC(edG.Text.numberOfLines,NumNewLines);
  390.     lst.AddMarkBefore(edG.Text.lineList,NewList,edG.Text.actLinePtr);
  391.     INCL(edG.Text.status,edG.modified);
  392.     edG.Text.actLinePtr := NewList.head(edG.Line);
  393.     IF edG.Text.line = edG.Text.topLine THEN
  394.       edG.Text.topLinePtr := edG.Text.actLinePtr; END;
  395.   END;
  396.   edD.TextLoad;
  397.   edD.SetWindowParams;
  398.   edD.TextRedisplay;
  399. END doLoad;
  400.  
  401.  
  402. PROCEDURE doSource*;
  403. VAR
  404.   len: INTEGER;
  405.   Buffer: edG.StringPtr;
  406.   File: fs.File;
  407. BEGIN
  408.   ol.New(Buffer,sys.SIZE(edG.String));
  409.   IF Buffer=NIL THEN
  410.     INCL(edG.Status,edG.memoryFail); edG.Rc := edE.cmdSevere;
  411.     RETURN;
  412.   END;
  413.   IF fs.Open(File,edG.Arg[0]^,FALSE) THEN
  414.     LOOP
  415.       len := fs.ReadStringLen(File,Buffer^);
  416.       IF len = -1 THEN
  417.         IF File.status # fs.eof THEN
  418.           edG.Rc := edE.cmdSevere; edL.Title(ReadError);
  419.         END;
  420.         EXIT;
  421.       ELSIF len # 0 THEN
  422.         REPEAT
  423.           DEC(len);
  424.           IF Buffer[len]=ASCII.ht THEN Buffer[len] := 20X; END;
  425.         UNTIL len = 0;
  426.         edG.ExecCmd(Buffer);
  427.       END;
  428.     END; (* LOOP *)
  429.     IF fs.Close(File) THEN END;
  430.   ELSIF NOT (sourceDoNotTitle IN edG.ArgSet) THEN
  431.     edG.Rc := edE.cmdError; edL.Title(FileNotFound);
  432.   END;
  433.   DISPOSE(Buffer);
  434. END doSource;
  435.  
  436. (*-----------------------------------------------------------------------*)
  437.  
  438. PROCEDURE SaveLines(Name: ARRAY OF CHAR; start,end: edG.LinePtr);
  439. VAR
  440.   next: edG.LinePtr;
  441.   File: fs.File;
  442.   ok: BOOLEAN;
  443.   i, j, k: INTEGER;
  444.   ptr: e.STRPTR;
  445. BEGIN
  446.   IF NOT fs.Open(File,Name,TRUE) THEN
  447.     edL.Title(UnableToOpenFile); edG.Rc := edE.cmdSevere;
  448.     RETURN;
  449.   END;
  450.   REPEAT
  451.     IF edG.saveTabs IN edG.Text.status THEN
  452.       ptr := sys.VAL(e.STRPTR,start(edG.Line).string);
  453.       i := 0; j := 0;
  454.       WHILE ptr^[0] # "\o" DO
  455.         Dirname[i] := ptr^[0];
  456.         IF (j = 7) AND (Dirname[i] = ' ') AND (Dirname[i-1] = ' ') THEN
  457.           k := j;
  458.           WHILE (k >= 0) AND (Dirname[i] = ' ') DO
  459.              DEC(k);
  460.              DEC(i);
  461.           END;
  462.           INC(i);
  463.           Dirname[i] := "\t";
  464.         ELSE
  465.           CASE Dirname[i] OF
  466.           "\"", "\'", "\`", "(":
  467.             j := str.Length(ptr^);
  468.             e.CopyMem(ptr^,Dirname[i],j+1);
  469.             INC(ptr,j); INC(i,j);
  470.           ELSE END;
  471.         END;
  472.         INC(ptr);
  473.         INC(i);
  474.         j := (j+1) MOD 8;
  475.       END;
  476.       Dirname[i] := "\o";
  477.       ok := fs.WriteString(File,Dirname);
  478.     ELSE
  479.       ok := fs.WriteString(File,start(edG.Line).string^);
  480.     END;
  481.     IF ok AND (start # end) THEN
  482.       start := start.next(edG.Line);
  483.     ELSE
  484.       start := NIL;
  485.     END;
  486.   UNTIL start = NIL;
  487.   IF ok THEN
  488.     edL.Title(edG.Okay); edG.Rc := edE.cmdValid2;
  489.   ELSE
  490.     edL.Title(WriteFailed); edG.Rc := edE.cmdSevere;
  491.   END;
  492.   ok := fs.Close(File);
  493. END SaveLines;
  494.  
  495.  
  496. PROCEDURE doSave*;
  497. VAR
  498.   SaveList: lst.List;
  499. BEGIN
  500.   edD.PutBackLine;
  501.   SaveList := edG.Text.lineList;
  502.   IF (saveBlock IN edG.ArgSet) THEN
  503.     IF NOT edB.BlockSpecified() THEN RETURN; END;
  504.     e.CopyMem(edG.Block,SaveList,sys.SIZE(SaveList));
  505.   ELSIF NOT (saveAs IN edG.ArgSet) THEN
  506.     edG.Arg[0] := sys.ADR(edG.Text.name);
  507.   END;
  508.   SaveLines(edG.Arg[0]^,SaveList.head(edG.Line),SaveList.tail(edG.Line));
  509.   IF (edG.Rc < edE.cmdFailed) THEN
  510.     IF NOT (saveBlock IN edG.ArgSet) THEN
  511.       EXCL(edG.Text.status,edG.modified);
  512.     ELSIF saveAs IN edG.ArgSet THEN
  513.       GetPathAndName(edG.Arg[0]^,edG.Arg[0]^,edG.Text.name);
  514.     END;
  515.   END;
  516. END doSave;
  517.  
  518. (*-----------------------------------------------------------------------*)
  519.  
  520. PROCEDURE doFileReq*;
  521. VAR
  522.   doDo: edG.ComProc;
  523.   hail: edG.StringPtr;
  524. BEGIN
  525.   IF edG.fileReqAvail IN edG.Status THEN
  526.     Filename := "";
  527.     IF saveAs IN edG.ArgSet THEN
  528.       hail := sys.ADR(SaveAs);
  529.       doDo := doSave;
  530.       e.CopyMemQuick(edG.Text.name,Filename,edG.FileNameLength);
  531.     ELSIF saveBlock IN edG.ArgSet THEN
  532.       IF NOT edB.BlockSpecified() THEN RETURN; END;
  533.       hail := sys.ADR(SaveBlock);
  534.       doDo := doSave;
  535.     ELSIF newFile IN edG.ArgSet THEN
  536.       hail := sys.ADR(NewFile);
  537.       doDo := doLoad;
  538.     ELSE
  539.       hail := sys.ADR(InsFile);
  540.       doDo := doLoad;
  541.     END;
  542.     IF FileReq(hail) THEN
  543.       edG.Arg[0] := sys.ADR(Filename);
  544.       doDo;
  545.     ELSE
  546.       edG.Rc := edE.cmdValid1;
  547.     END;
  548.   ELSE
  549.     edL.Title(FileReqNotAvailable); edG.Rc := edE.cmdError;
  550.   END;
  551. END doFileReq;
  552.  
  553. (*-----------------------------------------------------------------------*)
  554.  
  555. PROCEDURE doChFilename*;
  556. BEGIN
  557.   e.CopyMemQuick(edG.Arg[0]^,edG.Text.name,edG.FileNameLength);
  558. END doChFilename;
  559.  
  560.  
  561. PROCEDURE doCD*;
  562. VAR
  563.   oldLock, Lock: d.FileLockPtr;
  564. BEGIN
  565.   oldLock := d.CurrentDir(edG.Text.dirLock);
  566.   Lock := d.Lock(edG.Arg[0]^,d.sharedLock);
  567.   IF Lock # NIL THEN
  568.     d.UnLock(d.CurrentDir(oldLock));
  569.     edG.Text.dirLock := Lock;
  570.   ELSE
  571.     IF d.CurrentDir(oldLock)=NIL THEN END;
  572.     edG.Rc := edE.cmdFailed; edL.Title(UnableToCD);
  573.   END;
  574. END doCD;
  575.  
  576. (*-----------------------------------------------------------------------*)
  577.  
  578. PROCEDURE doSaveMap*;
  579. VAR
  580.   ptr: edG.StringPtr;
  581.   hash: edK.HashPtr;
  582.   i,len : INTEGER;
  583.   soc, eoc, ksoc, keoc: CHAR;
  584.   sysalso: BOOLEAN;
  585.   File: fs.File;
  586.   Buffer: edG.String;
  587. BEGIN
  588.   IF NOT fs.Open(File,edG.Arg[0]^,TRUE) THEN
  589.     edL.Title(UnableToOpenFile); edG.Rc := edE.cmdSevere;
  590.     RETURN;
  591.   END;
  592.   sysalso := saveSysMap IN edG.ArgSet;
  593.   i := 0;
  594.   REPEAT
  595.     hash := edK.HashList[i];
  596.     WHILE hash # NIL DO
  597.       IF (hash.len # 0) OR sysalso THEN
  598.         soc := "("; eoc := ")"; ksoc := "("; keoc := ")";
  599.         ptr := hash.map;
  600.         LOOP
  601.           IF (ptr[0] = 0X) OR (ptr[0] = "(") THEN EXIT; END;
  602.           IF ptr^ = "`" THEN
  603.             soc := "`"; eoc := "'";
  604.             EXIT;
  605.           END;
  606.           INC(ptr);
  607.         END; (* LOOP *)
  608.         ptr := edK.cqTOa(hash.code,hash.qual);
  609.         len := str.Length(ptr^)-1;
  610.         IF (ptr[len] = "(") OR (ptr[len] = ")") THEN
  611.           ksoc := "`"; keoc := "'"; END;
  612.         Printf.SPrintf6(Buffer,"map %lc%s%lc %lc%s%lc",
  613.           ORD(ksoc),ptr,ORD(keoc),ORD(soc),hash.map,ORD(eoc));
  614.         IF NOT fs.WriteString(File,Buffer) THEN
  615.           IF fs.Close(File) THEN END;
  616.           edL.Title(WriteFailed); edG.Rc := edE.cmdSevere;
  617.           RETURN;
  618.         END;
  619.       END; (* IF hash.len#0 ... *)
  620.       hash := hash.next;
  621.     END; (* WHILE *)
  622.     INC(i);
  623.   UNTIL i = edK.Hashsize;
  624.   IF fs.Close(File) THEN END;
  625.   edL.Title(edG.Okay);
  626. END doSaveMap;
  627.  
  628. (*-----------------------------------------------------------------------*)
  629.  
  630. PROCEDURE GetConfig*;
  631. VAR
  632.   config: fs.File;
  633. BEGIN
  634.   e.CopyMemQuick(edG.StdWindow,edG.Config.edges,sys.SIZE(edG.Config.edges));
  635.   edG.Config.screenDepth := 0;
  636.   IF fs.Open(config,ConfigFileName,FALSE) THEN
  637.     IF NOT fs.Read(config,edG.Config) THEN
  638.       CASE config.status OF
  639.         fs.toofar, fs.eof:|
  640.       ELSE
  641.         edL.Title(ReadError); edG.Rc := edE.cmdSevere;
  642.       END;
  643.     END;
  644.     IF fs.Close(config) THEN END;
  645.   END;
  646. END GetConfig;
  647.  
  648.  
  649. PROCEDURE doSaveConfig*;
  650. VAR
  651.   win: I.WindowPtr;
  652.   config: fs.File;
  653. BEGIN
  654.   IF fs.Open(config,ConfigFileName,TRUE) THEN
  655.     e.CopyMemQuick(edG.Text.window.leftEdge,
  656.                    edG.Config.edges,sys.SIZE(edG.Config.edges));
  657.     IF NOT fs.Write(config,edG.Config) THEN
  658.       edL.Title(WriteFailed); edG.Rc := edE.cmdSevere; END;
  659.     IF fs.Close(config) THEN END;
  660.   END;
  661. END doSaveConfig;
  662.  
  663. (*-----------------------------------------------------------------------*)
  664.  
  665. BEGIN
  666.   INCL(edG.Status,edG.fileReqAvail);
  667.   IF asl.asl=NIL THEN
  668.     arpbase := e.OpenLibrary("arp.library",39);
  669.     IF arpbase = NIL THEN
  670.       EXCL(edG.Status,edG.fileReqAvail);
  671.     END;
  672.   END;
  673. CLOSE
  674.   IF arpbase#NIL THEN e.CloseLibrary(arpbase) END;
  675.  
  676. END EdFileTools.
  677.  
  678.